//
//  main.cpp
//  Algo3TP1
//
//  Created by Jonathan Melnik on 4/5/14.
//  Copyright (c) 2014 ___JonathanMelnik___. All rights reserved.
//

#include <iostream>
#include <vector>

using namespace std;

struct CamionesPorDia
{
    int dia;
    int camiones;
};

void mergesort(int *a, int n);
void maximizarCamiones(string &entrada);

int main(int argc, const char * argv[])
{
    string line;
    while (getline(cin, line)) {
        if (line[0] == '0') {
            break;
        }
        maximizarCamiones(line);
    }
    return 0;
}

void maximizarCamiones(string &entrada) {
    vector<string> entradaSplit; // el vector tiene costo amortizado para insercion
    int fromIndex = 0;
    int length = 0;
    for(int i=0; i<entrada.length(); i++) {
        if(i == entrada.length() - 1) {
            length++;
            entradaSplit.push_back(entrada.substr(fromIndex, length));
        } else if(entrada[i] == ' ') {
            entradaSplit.push_back(entrada.substr(fromIndex, length));
            fromIndex = i+1;
            length = 0;
        } else {
            length++;
        }
    }
    
    int D = atoi(entradaSplit[0].c_str());
    int n = atoi(entradaSplit[1].c_str());
    
    int entradaParsedLen = (int)entradaSplit.size()-2;
    int* entradaParsed = new int[entradaParsedLen];
    for(int i= 2; i<entradaSplit.size(); i++) {
        entradaParsed[i-2] = atoi(entradaSplit[i].c_str());
    }
    
    mergesort(entradaParsed, n);
    
    int diasCount = 0;
    int prevDia = -1;
    for(int i=0; i<entradaParsedLen; i++) {
        if(entradaParsed[i] != prevDia) {
            diasCount++;
            prevDia = entradaParsed[i];
        }
    }
    
    CamionesPorDia* camionesPorDia = new CamionesPorDia[diasCount];
    prevDia = -1;
    int index = 0;
    for(int i=0; i<entradaParsedLen; i++) {
        if(prevDia != entradaParsed[i]) {
            camionesPorDia[index].dia = entradaParsed[i];
            camionesPorDia[index].camiones = 1;
            prevDia = entradaParsed[i];
            index++;
        } else {
            camionesPorDia[index-1].camiones++;
        }
    }
    
    int maxSumCamiones = 0;
    int maxSumStartIndex = 0;
    int startIndex = 0;
    int endIndex = 0;
    int sumCamiones = 0;
    // El intervalo que chequeo en cada iteracion es [startIndex, endIndex]
    for(startIndex=0; startIndex<diasCount; startIndex++) {
        // sumo los camiones que van estan en el intervalo [startIndex, endIndex]
        // esta suma la primera vez se hace para todos los elementos en el intervalo
        // y cada iteracion subsiguiente se hace solo para los elementos que no estaban
        // en el intervalo considerado en la iteracion anterior
        while(endIndex < diasCount && camionesPorDia[endIndex].dia - camionesPorDia[startIndex].dia < D) {
            sumCamiones += camionesPorDia[endIndex].camiones;
            endIndex++;
        }
        // si la sumatoria del intervalo es mayor a maxSum entonces me guardo
        // el valor de la sumatoria y el indice del inicio del intervalo
        if(sumCamiones > maxSumCamiones) {
            maxSumCamiones = sumCamiones;
            maxSumStartIndex = startIndex;
        }
        // resto los camiones del dia startIndex, para no tenerlos en cuenta
        // en el intervalo siguiente
        sumCamiones -= camionesPorDia[startIndex].camiones;
        
        if(endIndex >= diasCount) {
            break;
        }
    }

    cout << camionesPorDia[maxSumStartIndex].dia << " " << maxSumCamiones << endl;
}

void _mergesort(int *a, int*b, int low, int high);

void mergesort(int *a, int n) {
    int* b = new int[n];
    _mergesort(a, b, 0, n-1);
}

void merge(int *a, int *b, int low, int pivot, int high)
{
    int h,i,j,k;
    h=low;
    i=low;
    j=pivot+1;
    
    while((h<=pivot)&&(j<=high))
    {
        if(a[h]<=a[j])
        {
            b[i]=a[h];
            h++;
        }
        else
        {
            b[i]=a[j];
            j++;
        }
        i++;
    }
    if(h>pivot)
    {
        for(k=j; k<=high; k++)
        {
            b[i]=a[k];
            i++;
        }
    }
    else
    {
        for(k=h; k<=pivot; k++)
        {
            b[i]=a[k];
            i++;
        }
    }
    for(k=low; k<=high; k++) a[k]=b[k];
}

void _mergesort(int *a, int*b, int low, int high)
{
    int pivot;
    if(low<high) //si es la misma posicion termine
    {
        pivot=(low+high)/2; //si no divido el arreglo a la mitad y trabajo con las dos partes
        _mergesort(a,b,low,pivot);
        _mergesort(a,b,pivot+1,high);
        merge(a,b,low,pivot,high);
    }
}